U.S. Pat. No. 4,405,829 September/1983 Rivest et al. . . . 178/22.1
U.S. Pat. No. 4,309,569 January/1982 Merkle . . . 178/22.08
U.S. Pat. No. 4,881,264 November/1989 Merkle . . . 380/25
ISO 9594-8, Information Technologyxe2x80x94Open Systems Interconnectionxe2x80x94The Direction: Authentication framework, Sep. 15, 1995.
National Institute of Standards and Technology, NIST FIPS PUB 190, xe2x80x9cSecure Hash Standard,xe2x80x9d U.S. Department of Commerce, May 1993.
National Institute of Standards and Technology, NIST FIPS PUB 186, xe2x80x9cDigital Signature Standard,xe2x80x9d U.S. Department of Commerce, May 1994.
B. Schneier, Applied Cryptography (2nd ed.), John Wiley and Sons, 1996.
1. Field of the Invention
This invention relates generally to data security, information security, and cryptography, and specifically to systems for constructing digitally-signed lists and determining whether particular values are present on such lists. The invention has specific application to revocation of digital certificates or other types of digital data items and for determining whether such data items have been revoked.
2. Description of the Background Art
Asymmetric (public key) cryptologic techniques are widely used in security protocols for applications such as secure e-mail, electronic commerce, encrypted voice and video communications, and security on the World Wide Web. The RSA cryptosystem, described in U.S. Pat. No. 4,405,829 to Rivest et al (1983), and the Digital Signature Algorithm (DSA), described in U.S. Pat. No. 5,231,668, to Kravitz, are examples of asymmetric functions. Asymmetric cryptosystems systems typically involve a secret private key, which is used for digital signing or decryption, and a non-confidential public key derived from the private key, which is used for signature verification or encryption. For general information about RSA, DSA, and other asymmetric cryptosystems, the reader is referred to Applied Cryptography. 
Before using a public key to encrypt a confidential message or verify a signature, a party in an electronic communications protocol generally must confirm the identity of the party holding the private key. An electronic communications protocol defines conventions allowing two or more computers or other electronic devices to exchange digital data or messages via a communications channel. Without such confirmation, an attacker could substitute a legitimate public key with another for which the attacker knows the private key. Digital certificates are the most common solution to this problem. The holder of the private key provides its corresponding public key to a widely-trusted Certificate Authority (CA) along with acceptable identification. The CA then issues a certificate, which typically consists of a digital signature on a specially-formatted block of data containing the user""s name, the user""s public key, the certificate issuance and expiration dates, and the certificate serial number. The recipient of a digital certificate who trusts the issuing CA can use the CA""s (already trusted) public key to verify the signature. If the signature is valid and if the CA is trustworthy, the recipient can trust that the person identified in the certificate holds the private key corresponding to the public key in the certificate. The ISO 9594-8 standard defines techniques and data formats for computing and verifying digital signatures and certificates.
Certificates often need to be revoked due to unexpected events such as compromise, theft, or loss of the device containing the private key. A certificate might also need to be revoked if a user has lost the privileges granted by the certificate. In general, a certificate""s status might be good, revoked, or pending, as well as other possibilities that will be appreciated by those skilled in the art.
In large open networks such as the Internet, certificate status determination, specifically certificate revocation, presents enormous challenges. The Internet is expected to have hundreds of millions of users worldwide soon. It is desirable that certificate revocation messages propagate as quickly as possible to all users who might otherwise accept the invalid certificate. Thus, there are difficult design constraints which a successful system must satisfy:
1. Network applications are sensitive to latency. A good solution should minimize the number of additional network connections and data exchanges required.
2. The system must work on a global scale and work on a broad range of systems with different levels of connectivity.
3. The system must be distributable so that critical information can be cached in many locations at once to minimize the number of long-distance network connections.
4. The system must be cryptographically secure.
Previous certificate revocation mechanisms, such as ISO 9594-8, use a type of digitally-signed structure called a Certificate Revocation List (CRL) which is issued periodically by the CA and lists the serial numbers of certificates issued by the CA which have been revoked. FIG. 1 shows the structure of a typical CRL 101, which consists of the issuer""s name, a field identifying the signature algorithm, the date and time of issuance, and a list of revoked certificates, followed by a digital signature of the above information. To determine if a particular certificate is revoked, one obtains an up-to-date CRL from the appropriate CA, verifies that the digital signature in the CRL is valid, then searches the list of revoked certificates to determine whether the certificate in question is revoked. If the certificate is not on the list, it is assumed to be valid.
Because the complete CRL must be obtained and verified to determine the revocation status of a single certificate, CRLs do not scale well to large networks. In particular, existing certificate revocation mechanisms suffer from a number of disadvantages:
(a) CRLs can become extremely large, making them inefficient to transmit or process. For example, a very large system might have several million revoked certificates, resulting in CRLs which are many megabytes in size.. To determine whether a particular certificate is valid, one must download a recent CRL in its entirety and process the entire list to verify the digital signature. For a large network, the required network bandwidth can be prohibitively large, especially if every user needs to download new CRLs often. The time required to process a large list can also be an issue.
(b) Only mechanisms recognized and supported by the certificate recipient can be used to revoke certificates. In most cases, only revocations issued by the CA are accepted. Additional revocation mechanisms cannot be added easily.
(c) Because CAs are entrusted with both certificate issuance and revocation, physical destruction of a CA""s private key could result in a situation where certificates could no longer be revoked without revoking the CA""s public key.
(d) Verifiers must be able to obtain up-to-date CRLs from every supported CA. Certificate chaining makes this particularly difficult since there can easily be an extremely large number of CAs and multiple CAs per certificate chain.
Present techniques for determining whether types of data other than certificates are present on digitally-signed lists suffer from the same scalability problems. On large networks such as the Internet such systems will typically suffer from poor latency and extremely large bandwidth requirements. These limitations arise because existing techniques either require active network connections to a trusted server at transaction time or require replication of CRLs or other digitally-signed lists containing all elements of the list.
Accordingly, it is an object of the invention to greatly reduce the processing effort, network bandwidth, network latency, data storage, and data replication requirements needed to determine whether a particular certificate has been revoked. In particular, the invention allows certificate status to be determined without knowledge of the entire list of revoked certificates and without having to search the entire list of revoked certificates.
Another object of the invention is to simplify the addition of new revocation mechanisms, such as revocation by certificate holders, without altering existing revocation mechanisms.
Another object of the invention is to allow revocations from many CAs to be included efficiently in a single database, thereby allowing a single trusted source for certificate revocation messages.
Another object of the invention is to provide a certificate revocation system whose operation is open to public scrutiny to ensure that certificates are not maliciously revoked and that revoked certificates are not marked as valid.
In general, the invention can be used to determine whether data items of any type are present on a digitally-signed list without requiring that the verifier retrieve the entire list. It should be readily apparent to a reader skilled in the art that the problem of determining securely whether a data item belongs to a list of data items has applications to many problems beyond certificate revocation. For example, an Internet user might want to determine whether a digitally-signed Java application has been revoked as having harmful side effects.
Briefly, the present invention typically includes at least one tree issuing device, one or more confirmation issuers, and at least one verification device.
The tree issuing device assembles a list of data items, which can have any content but would typically be a list of serial numbers identifying revoked digital certificates. The issuer sorts the list, optionally removes any duplicate entries, then adds a beginning-of-list marker and an end-of-list marker. Each pair of adjacent entries in this sorted list specifies a range between which there are no list entries. Except for the beginning and end markers, each list entry appears in two ranges, once as a minimum value and once as a maximum value. A hash tree is then constructed where leaf nodes correspond to ranges in the list. Because the tree""s leaf nodes define intervals, this structure is referred to as an interval hash tree. A binary tree such as those described in U.S. Pat. No. 4,309,569 to Merkle (1982) would typically be used, but those skilled in the art will appreciate that a variety of other hash tree structures are also suitable (for example, as described in U.S. Pat. No. 4,881,264 to Merkle (1989)). Merkle uses hash trees to reduce the cost per signature when computing a large number of digital signatures by combining a large number of items into a single root node which can be digitally signed. Merkle""s hash tree techniques produce assurances that particular items have been digitally signed. However, Merkle""s hash trees do not provide the capability disclosed herein, of cryptographically demonstrating that particular items were not included in the tree (except in the highly inefficient case where the verifier obtains the entire tree and searches it for the particular candidate item).
The tree issuing device digitally signs the tree""s root node (or nodes, if the chosen tree structure has multiple roots) with other data which would typically identify the issuer""s identity and the date and time.
A confirmation issuer obtains the hash tree including the root node digital signature. The tree may be obtained either separately from, or together with, its digitally signed root. In the latter case, the hash tree shall be considered to include its digitally signed root(s). These values could be obtained directly from the tree issuer, be computed independently, or be obtained from other sources. The confirmation issuer can be the same device as the tree issuer, or could be an independent device connected to the tree issuer via a communications channel. Confirmation issuers might also be included in devices including, but not limited to, network servers, firewalls, or directory servers and might be assigned to serve a particular region of a network or subnetwork.
The verification device (verifier) begins with a xe2x80x9ccandidate data itemxe2x80x9d whose status on the list is to be determined. The verifier sends the candidate data item (or a representation thereof) to the confirmation issuer. The confirmation issuer locates a leaf node whose minimum range value is no larger than the candidate data item and whose maximum range value is no smaller than the candidate data item. The confirmation issuer then sends the verifier the appropriate range, the digitally-signed root node, and the additional nodes needed to cryptographically derive the root node from the leaf node. By cryptographically determining that the particular leaf can be used to reconstruct the root node, the verifier gains cryptographic assurance that the leaf was part of the original tree whose root node was digitally signed. The leaf is said to be cryptographically bound to the root. Note that the confirmation issuer does not need a private key, or knowledge of tree issuer""s private key, since it does not generate any new digital signatures.
The verifier confirms that the signature on the header is correct and comes from a trusted tree issuer; that the date, name, and other information included in the root node digital signature are appropriate; that the root node can be constructed from the leaf node using the specified supporting nodes; and that the candidate data item is within the range specified by the given leaf node. If any of the above verification steps fail, the assurance is bad and item""s status on the list cannot be determined. If the verification steps are successful and either range endpoint equals the data item, the verifier has cryptographic assurance that the data item is present on the list. If the smaller range endpoint is less than the data item and the larger endpoint is larger than the item, the verifier has cryptographic assurance that the item is not present on the list.
In addition to the embodiments described above, another illustrated embodiment does not use ranges, but rather uses a hash tree constructed from a sorted list of data items such that two adjacent leaves spanning a candidate data item provide cryptographic assurance that the candidate data item is not present on the list. Yet another illustrated embodiment does not use ranges, but rather uses the hash tree to build digitally signed assertions that specific items are not on the list. Still another illustrated embodiment does not use hash trees, but rather uses individually signed ranges.